package com.tedu.API.list;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

/**
 * 数组：遍历数据  遍历数据三种：普通for 增强for  Arrays工具类
 * 集合：遍历数据  遍历数据三种：普通for 增强for  Iterator迭代器
 * 保存数据优选：集合----遍历数据优选迭代器
 * Iterator迭代器   接口------依赖Collection提供方法：iterator()
 *
 * 集合迭代器使用方式：问，取，删
 */
public class Collection_IteratorAPI {
    @Test
    public void testIterator() {
        Collection c1 = new ArrayList();
        c1.add("one");
        c1.add("two");
        c1.add("three");
        /**
         * iterator()方法：获取集合迭代器----遍历数据
         */
        Iterator it = c1.iterator();
        //迭代器的使用：1.问--集合中是否存在元素【集合元素不确定】
        /**
         * hasNext()  返回值:boolean
         * 作用：判断集合当中是否还有元素可以遍历，返回true存在元素，返回false没有元素
         *
         */
        while (it.hasNext()) {
            //hasNext() 迭代器中的问操作
            //2.取---如果集合当中存在元素:取出元素---next()
            /**
             * E next()  返回值：E泛型  简单理解：Object
             * 作用：遍历取出元素
             */
            String str = (String) it.next();
            System.out.println("集合迭代器" + str);
        }
    }
    /**
     * 集合三种遍历方式：Iterator迭代器【问取操作】
     *               普通for
     *               增强for
     *               遍历同时对集合做元素删除操作---Interator迭代器
     *
     *               作业：增强for删除testRemove单元测试集合包含元旦元素
     *                  作业测试名：testHomeWork()
     */
    @Test
    public void testFor(){
        Collection collection=new ArrayList();
        //添加10个元素，普通for增加元素：0~9
        for (int i=0;i<=9;i++){
            collection.add(i);
        }
        System.out.println("打印集合数据"+collection);
        //获取集合所有数据
        //1.使用普通for
        for (int i=0;i<collection.size();i++){
            System.out.println("普通for循环"+((List)collection).get(i));

        }
        //2增强for(Integer i:集合名)
        //     for(Object i:集合名)
        //collection是顶级集合--存任何数据--Object类型
        for (Object i:collection){
            System.out.println("增强for遍历的集合"+i);
        }
    }
    /**
     * 遍历的同时对集合做元素删除操作---Interator迭代器
     * Interator迭代器--删除数据【真删】
     * remove() 方法 返回值：void
     * 作用：删除迭代器获取的元素 【理解：next()取元素之后，删除】
     * Interator迭代器使用规则：问取删
     */
    @Test
    public void testRemove(){
        Collection c=new ArrayList();
        c.add("十一");c.add("元旦");c.add("春节");c.add("元宵");
        //创建集合Collection ---遍历同时删除春季
        System.out.println("collection"+c);
        //1.依赖集合Collection---提供Iterator()方法  创建迭代器对象
        Iterator it=c.iterator();
        //2使用迭代器中问取删
        while(it.hasNext()){
            //3获取集合当中的元素 next() 获取集合当中的元素，默认类型Object
            String str=(String)it.next();
            //4.删除集合中存在春节的元素
            //4.1如果集合元素名叫春节---删除
            if ("春节".equals(str)) {
                it.remove(); //next() 拿到元素之后删除操作
            }
            //集合当中 c.remove("春节");
        }
        System.out.println("迭代器删除操作"+c);

    }
    /**
     * 泛型：与集合搭配使用   E  element 元素 理解：Object
     * JDK1.5之后推出新特性，集合存任何数据，获取数据非常混乱
     *                    对象，整形，小数型，  取  Object 知道类型
     * 泛型主要功能是约束集合类型！！
     * 泛型编译器认可的，JVM虚拟机不认可，认为：Object对象
     * 使用泛型的好处：1.约束数据的类型，数据稳定【统一类型】,获取元素无需造型
     *              2.类型：对象---继承以及继承之后方法的使用super
     * 语法:Collection<类型:引用类型，包装类型> c=
     *             new ArrayList<类型:引用类型，包装类型>();
     *
     */
    @Test
    public void testElement(){
        //JDK1.5  泛型写法
        Collection<String> c1=new ArrayList<String>();
        //JDK1.7  泛型写法  建议使用
        Collection<String> c2=new ArrayList<>();
        c2.add("1");c2.add("老八");
        Iterator<String> it=c2.iterator();
        while(it.hasNext()){
            String str=it.next();
            System.out.println(str);
        }
        Collection<Integer> c3=new ArrayList<>();

        //泛型定义：？ 代表：不限制类型【没有意义的值-null】项目非常大才会看到
        Collection<?> c4=new ArrayList<>();
        c4.add(null);  //只能存没有意义的值：引用类型--默认值：null

    }

    /**
     * 泛型中通配符  ？ 【任意类型】 的使用
     * ? 【任意类型】 extends 父类
     * 【任意类型：父类的所有子类】  约束--
     */
    @Test
    public void testE(){
        //测试：  创建父类：Fruit--属性：名字  方法：获取名字 构造器
        //       创建两个子类:Apple,Orange----构造器：传水果的名字
        //       创建类：TestJob   限定传入的子类一定是继承父类的操作
        //       约束--静态方法  printFruit() 约束父类的子类才能使用
        //       单元测试：testE()测试--约束是否限制成功
        //   实际的开发应用中，高级程序员制定
        //测试：创建集合--传入参数
        Collection<Apple> apples=new ArrayList<>();
        apples.add(new Apple());  //存入apple对象
        TestJob.printFruit(apples);  //上界限定操作
        Collection<Pear> pears=new ArrayList<>();
        pears.add(new Pear());
    }
    @Test
    public void testHomeWork(){
//        作业：增强for删除testRemove单元测试集合包含元旦元素
//                *                  作业测试名：testHomeWork()
        /**
         * Iterator通过迭代的方式--遍历元素--遍历同时删除
         * 增强for【不可以在遍历的同时删除元素】
         * ConcurrentModificationException  并发修改异常
         * 产生原因：增强for底层遍历采用Iterator遍历---迭代器删除元素
         *                        集合元素
         *            增强for中删除元素的方法用错
         */
        Collection<String> c=new ArrayList<>();
        c.add("十一");c.add("元旦");c.add("春节");c.add("元宵");
        Iterator<String> it=c.iterator();
        while(it.hasNext()){
            String str=it.next(); //取元素
            if ("元旦".equals(str)){
                it.remove();
            }
        }
//        for (String i: c){
//            if("元旦".equals(i)){
//                c.remove("元旦");
//            }
//        }
//        System.out.println(c);
        //增强for循环删不掉
    }



}
//集合重点： Collection常用方法，Iterator迭代器，泛型【超级重点】

